home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 22 / AACD 22.iso / AACD / Sound / Subspace68k / src / Waveshapes4.c < prev   
Encoding:
C/C++ Source or Header  |  2001-05-04  |  10.3 KB  |  446 lines
  1.  
  2. #include <exec/types.h>
  3. #include <math.h>
  4.  
  5. #ifdef __SASC
  6.     #define M_PI PI
  7. #endif
  8. #ifdef __VBCC__
  9. //#define   M_PI 3.14159265358979323846
  10. #define   M_PI 3.1415927
  11. #endif
  12.  
  13. float rnd(float max);
  14.  
  15. float wa0[2], wa1[2], wa2[2], wa3[2], wa4[2], wa5[2], wa6[2], wa7[2], wa8[2];
  16. float wb0[2], wb1[2], wb2[2], wb3[2], wb4[2], wb5[2], wb6[2], wb7[2], wb8[2];
  17.  
  18. extern int TimeWave;
  19. extern WORD     *PluginSamples;
  20.  
  21.  
  22. void InitWave(UBYTE WaveNum, int BufNum) {
  23.     float a0,a1,a2,a3,a4;
  24.     a0=a1=a2=a3=a4=0.0;
  25.     switch(WaveNum) {
  26.         /****************************************/
  27.         case 0:
  28.         break;
  29.         /****************************************/
  30.         case 1:
  31.         break;
  32.         /****************************************/
  33.         case 2:
  34.             a0 = 0.1 + rnd(0.2);
  35.         break;
  36.         /****************************************/
  37.         /** Radar Sweep                        **/
  38.         case 3:
  39.             a0 = 0.7 + rnd(1.1);
  40.         break;
  41.         /****************************************/
  42.         /** Flower Power                       **/
  43.         case 4:
  44.             a0 = 2.0 + (float)((ULONG)(0.99 * rnd(4.0)));
  45.             a1 = M_PI * (float)(2 - (ULONG)a0 % 2);
  46.             a2 = 0.2  + rnd(0.2);
  47.             a3 = 0.65 + rnd(0.22);
  48.         break;
  49.         /****************************************/
  50.         /** Spinit                             **/
  51.         case 5:
  52.             a0 = 0.25 + rnd(0.4);
  53.         break;
  54.         /****************************************/
  55.         /** Sine Waves                         **/
  56.         case 6:
  57.         break;
  58.         /****************************************/
  59.         /** Five                               **/
  60.         case 7:
  61.             a0 = cos(.3 + rnd(.6)) * 0.5;
  62.             a1 = sin(.5 + rnd(.4)) * 0.5;
  63.             a2 = cos(.1 + rnd(.8)) * 0.5;
  64.             a3 = sin(.2 + rnd(.7)) * 0.5;
  65.             a4 = cos(.6 + rnd(.3)) * 0.5;
  66.         break;
  67.         /****************************************/
  68.         /** Rotating Arcs                      **/
  69.         case 8:
  70.             a0 = 0.5 + rnd(0.2);
  71.             a1 = rnd(1.3) + 1.4;
  72.         break;
  73.         /****************************************/
  74.         /** Horizontal Sweep                   **/
  75.         case 9:
  76.         break;
  77.         /****************************************/
  78.         /** NTPU Squared                       **/
  79.         case 10:
  80.             a0 = 0.3 + rnd(0.4);
  81.             a1 = 0.4 * a0;
  82.         break;
  83.         /****************************************/
  84.         /** Particle Pulse                     **/
  85.         case 11:
  86.             a0 = rnd(3)+1;
  87.         break;
  88.         /****************************************/
  89.     }
  90.     wa0[BufNum] = a0;
  91.     wa1[BufNum] = a1;
  92.     wa2[BufNum] = a2;
  93.     wa3[BufNum] = a3;
  94.     wa4[BufNum] = a4;
  95. }
  96.  
  97. void CalcWave(UBYTE WaveNum, int BufNum) {
  98.     float tf;
  99.     float a0,a1,a2,a3,a4;
  100.     float b0,b1,b2,b3,b4,b5,b6,b7,b8;
  101.  
  102.     a0 = wa0[BufNum];
  103.     a1 = wa1[BufNum];
  104.     a2 = wa2[BufNum];
  105.     a3 = wa3[BufNum];
  106.     a4 = wa4[BufNum];
  107.     b0 = 0;
  108.     b1 = 0;
  109.     b2 = 0;
  110.     b3 = 0;
  111.     b4 = 0;
  112.     b5 = 0;
  113.     b6 = 0;
  114.     b7 = 0;
  115.     b8 = 0;
  116.     tf=((float)TimeWave) / 10.0;
  117.     switch(WaveNum) {
  118.         /****************************************/
  119.         case 0:
  120.         break;
  121.         /****************************************/
  122.         case 1:
  123.             b0 = tf * 0.0003;
  124.         break;
  125.         /****************************************/
  126.         case 2:
  127.             b0 = cos(tf * 0.2);
  128.             b1 = sin(tf * 0.2);
  129.         break;
  130.         /****************************************/
  131.         /** Radar Sweep                        **/
  132.         case 3:
  133.             b0 = cos(tf * a0);
  134.             b1 = sin(tf * a0);
  135.         break;
  136.         /****************************************/
  137.         /** Flower Power                       **/
  138.         case 4:
  139.             b0 = tf;
  140.         break;
  141.         /****************************************/
  142.         /** Spinit                             **/
  143.         case 5:
  144.             b0 = cos(a0 * tf);
  145.             b1 = sin(a0 * tf);
  146.         break;
  147.         /****************************************/
  148.         /** Sine Waves                         **/
  149.         case 6:
  150.         break;
  151.         /****************************************/
  152.         /** Five                               **/
  153.         case 7:
  154.             b0 = -1.0 * tf;
  155.             b1 = .3 * tf;
  156.             b2 = -.8 * tf + 1.23213;
  157.             b3 = .3 * tf;
  158.             b4 = -1.3 * tf;
  159.             b5 = -1.1 * tf + 4.45245;
  160.             b6 = -.63 * tf + 2.13213;
  161.             b7 = .7 * cos(b1);
  162.             b8 = .7 * sin(b1);
  163.         break;
  164.         /****************************************/
  165.         /** Rotating Arcs                      **/
  166.         case 8:
  167.             b0 = 0.3 * tf;
  168.         break;
  169.         /****************************************/
  170.         /** Horizontal Sweep                   **/
  171.         case 9:
  172.             b0 = sin(0.5*tf);
  173.         break;
  174.         /****************************************/
  175.         /** NTPU Squared                       **/
  176.         case 10:
  177.             b0 = cos(tf * 0.18);
  178.             b1 = sin(tf * 0.18);
  179.         break;
  180.         /****************************************/
  181.         /** Particle Pulse                     **/
  182.         case 11:
  183.             b0 = tf * 0.0003;
  184.         break;
  185.         /****************************************/
  186.     }
  187.     wb0[BufNum] = b0;
  188.     wb1[BufNum] = b1;
  189.     wb2[BufNum] = b2;
  190.     wb3[BufNum] = b3;
  191.     wb4[BufNum] = b4;
  192.     wb5[BufNum] = b5;
  193.     wb6[BufNum] = b6;
  194.     wb7[BufNum] = b7;
  195.     wb8[BufNum] = b8;
  196. }
  197.  
  198. void DrawWave(LONG *WaveX, LONG *WaveY, int Width, int Height, UBYTE WaveNum, int BufNum) {
  199.     LONG i,xs,ys,xd,yd;
  200.     LONG k;
  201.     LONG minx,maxx,miny,maxy;
  202.  
  203.     float scales,scaled,greater;
  204.     float xsf,ysf;
  205.     float xdf0,ydf0,xdf1,ydf1,xdf2,ydf2;
  206.     float wf,hf,tf;
  207.  
  208.     float a0, a1, a2, a3, a4;
  209.     float b0, b1, b2, b3, b4, b5, b6, b7, b8;
  210.     float c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10;
  211.  
  212.     a0 = wa0[BufNum];
  213.     a1 = wa1[BufNum];
  214.     a2 = wa2[BufNum];
  215.     a3 = wa3[BufNum];
  216.     a4 = wa4[BufNum];
  217.  
  218.     b0 = wb0[BufNum];
  219.     b1 = wb1[BufNum];
  220.     b2 = wb2[BufNum];
  221.     b3 = wb3[BufNum];
  222.     b4 = wb4[BufNum];
  223.     b5 = wb5[BufNum];
  224.     b6 = wb6[BufNum];
  225.     b7 = wb7[BufNum];
  226.     b8 = wb8[BufNum];
  227.  
  228.     wf=(float)Width;
  229.     hf=(float)Height;
  230.     tf=((float)TimeWave) / 10.0;
  231.  
  232.     minx = -(Width/2)  + 1;
  233.     maxx =  (Width/2)  - 1;
  234.     miny = -(Height/2) + 1;
  235.     maxy =  (Height/2) - 1;
  236.  
  237.     greater=1.0;
  238.     if(wf > greater) greater = wf;
  239.     if(hf > greater) greater = hf;
  240.  
  241.     scales = 1.0 / greater;
  242.     scaled = 1.0 / (greater/2.0);
  243.  
  244.     k=0;
  245.     for(xs=0; xs<(Width); xs++) {
  246.         ys = (PluginSamples[k++] >> 10) + (PluginSamples[k++] >> 10);
  247.  
  248.         xsf = ((float)xs) * scales;
  249.         ysf = ((float)ys) / 256.0;
  250.  
  251.         switch(WaveNum) {
  252.             /****************************************/
  253.             case 0:
  254.                 xdf0 = 2*xsf-1;
  255.                 ydf0 = ysf * 0.75;
  256.                 xdf1 = xdf0;
  257.                 ydf1 = ydf0;
  258.             break;
  259.             /****************************************/
  260.             case 1:
  261.                 c0 = ysf * 0.2 + .2;
  262.                 c1 = xsf * 6.28318530 + b0;
  263.                 xdf0 = c0 * cos(c1);
  264.                 ydf0 = c0 * sin(c1);
  265.                 xdf1 = xdf0;
  266.                 ydf1 = ydf0;
  267.             break;
  268.             /****************************************/
  269.             case 2:
  270.                 c0 = ysf * 0.25 + .2;
  271.                 c1 = 2.1 * (xsf-0.5);
  272.                 xdf0 =  b0 * c1 + b1 * c0;
  273.                 ydf0 = -b0 * c0 + b1 * c1;
  274.                 xdf1 =  b0 * c1 - b1 * c0;
  275.                 ydf1 =  b0 * c0 + b1 * c1;
  276.             break;
  277.             /****************************************/
  278.             /** Radar Sweep                        **/
  279.             case 3:
  280.                 c0   = ysf * 0.4 * xsf;
  281.                 xdf0 = -b0 * xsf - b1 * c0;
  282.                 ydf0 =  b0 * c0  - b1 * xsf;
  283.                 xdf1 = xdf0;
  284.                 ydf1 = ydf0;
  285.             break;
  286.             /****************************************/
  287.             /** Flower Power                       **/
  288.             case 4:
  289.                 c0   = a1 * xsf;
  290.                 c1   = a3 * cos(a0*c0) + 0.18 * ysf;
  291.                 xdf0 = c1 * cos(c0+a2*b0);
  292.                 ydf0 = c1 * sin(c0+a2*b0);
  293.                 xdf1 = xdf0;
  294.                 ydf1 = ydf0;
  295.             break;
  296.             /****************************************/
  297.             /** Spinit                             **/
  298.             case 5:
  299.                 c0   = 2 * xsf - 1;
  300.                 c1   = ysf * 0.6 + c0;
  301.                 xdf0 = - b0 * c0 - b1 * c1;
  302.                 ydf0 =   b0 * c1 - b1 * c0;
  303.                 xdf1 = - b0 * c0 + b1 * c1;
  304.                 ydf1 =   b0 * c1 + b1 * c0;
  305.             break;
  306.             /****************************************/
  307.             /** Sine Waves                         **/
  308.             case 6:
  309.                 c0   = - sin(6.2831853 * xsf);
  310.                 c1   = 0.4 * ysf;
  311.                 xdf0 = 2.0 * xsf - 1 - c0 * c1;
  312.                 ydf0 = 0.7 * cos( 6.2831853 * xsf ) + sqrt( 1 - c0*c0 ) * c1;
  313.                 xdf1 = xdf0;
  314.                 ydf1 = -ydf0;
  315.             break;
  316.             /****************************************/
  317.             /** Five                               **/
  318.             case 7:
  319.                 c0   = b7 * ( xsf - .1 ) + a0;
  320.                 c1   = b8 * ( xsf - .1 ) + a0;
  321.                 c2   = .7 * ( xsf - .1 ) * sin( b3 ) + a1;
  322.                 c3   = .7 * ( xsf - .1 ) * cos( b3 ) + a1;
  323.                 c4   = b7 * ( xsf - .1 ) + a2;
  324.                 c5   = b8 * ( xsf - .1 ) + a2;
  325.                 c6   = b7 * ( xsf - .1 ) + a3;
  326.                 c7   = b8 * ( xsf - .1 ) + a3;
  327.                 c8   = b7 * ( xsf - .1 ) + a4;
  328.                 c9   = b8 * ( xsf - .1 ) + a4;
  329.                 c10  = .7 * ysf;
  330.  
  331.                 switch(xs%5) {
  332.                     case 0:
  333.                         xdf0 = c0 * cos(b0) - c1 * sin(b0);
  334.                         ydf0 = c1 * sin(b0) + c0 * cos(b0) * c10;
  335.                     break;
  336.                     case 1:
  337.                         xdf0 = -(c0 * sin(b2) - c1 * cos(b2));
  338.                         ydf0 = -(c1 * cos(b2) + c0 * sin(b2) * c10);
  339.                     break;
  340.                     case 2:
  341.                         xdf0 = -(c4 * sin(b4) - c5 * cos(b4));
  342.                         ydf0 = -(c5 * cos(b4) + c4 * sin(b4) * c10);
  343.                     break;
  344.                     case 3:
  345.                         xdf0 = c6 * cos(b5) - c7 * sin(b5);
  346.                         ydf0 = c7 * sin(b5) + c6 * cos(b5) * c10;
  347.                     break;
  348.                     case 4:
  349.                         xdf0 = -c8 * cos(b6) - c9 * sin(b6);
  350.                         ydf0 = -c9 * sin(b6) + c8 * cos(b6) * c10;
  351.                     break;
  352.                 }
  353.                 xdf1 = xdf0;
  354.                 ydf1 = ydf0;
  355.             break;
  356.             /****************************************/
  357.             /** Rotating Arcs                      **/
  358.             case 8:
  359.                 c0   = a0 + .025 * ysf;
  360.                 c1   = b0 + a1 * xsf;
  361.  
  362.                 xdf0 = c0 * cos(c1);
  363.                 ydf0 = c0 * sin(c1);
  364.                 xdf1 = c0 * cos(c1 + 3.14159);
  365.                 ydf1 = c0 * sin(c1 + 3.14159);
  366.             break;
  367.             /****************************************/
  368.             /** Horizontal Sweep                   **/
  369.             case 9:
  370.                 c0   = 2 * (xsf - 0.5);
  371.                 c1   = 0.7 * b0 + ysf * 0.25;
  372.  
  373.                 xdf0 =  c1;
  374.                 ydf0 =  c0;
  375.                 xdf1 = -c1;
  376.                 ydf1 =  c0;
  377.             break;
  378.             /****************************************/
  379.             /** NTPU Squared                       **/
  380.             case 10:
  381.                 c0   = a1 * ysf + a0;
  382.                 c1   = 2.0 * a0 * (xsf - 0.5);
  383.  
  384.                 switch(xs%2) {
  385.                     case 0:
  386.                         xdf0 =   b0 * c1 + b1 * c0;
  387.                         ydf0 = - b0 * c0 + b1 * c1;
  388.                         xdf1 =   b0 * c1 - b1 * c0;
  389.                         ydf1 =   b0 * c0 + b1 * c1;
  390.                     break;
  391.                     case 1:
  392.                         xdf0 = - b0 * c1 - b1 * c0;
  393.                         ydf0 = - b0 * c0 + b1 * c1;
  394.                         xdf1 = - b0 * c1 + b1 * c0;
  395.                         ydf1 =   b0 * c0 + b1 * c1;
  396.                     break;
  397.                 }
  398.             break;
  399.             /****************************************/
  400.             /** NTPU Squared                       **/
  401.             case 11:
  402.                 c0   = fabs(ysf) * 0.85 + 0.05;
  403.                 c1   = xsf * 43.766877 - b0;
  404.  
  405.                 switch(xs%2) {
  406.                     case 0:
  407.                         xdf0 = c0 * cos(c1);
  408.                         ydf0 = c0 * sin(c1);
  409.                         xdf1 = c0 * cos(c1)+scaled;
  410.                         ydf1 = c0 * sin(c1);
  411.                     break;
  412.                     case 1:
  413.                         xdf0 = c0 * cos(c1);
  414.                         ydf0 = c0 * sin(c1)+scaled;
  415.                         xdf1 = c0 * cos(c1)+scaled;
  416.                         ydf1 = c0 * sin(c1)+scaled;
  417.                     break;
  418.                 }
  419.             break;
  420.             /****************************************/
  421.         }
  422.  
  423.         xd = xdf0/scaled;
  424.         yd = ydf0/scaled;
  425.         /**
  426.         if(xd < minx) xd = minx;
  427.         if(xd > maxx) xd = maxx;
  428.         if(yd < miny) yd = miny;
  429.         if(yd > maxy) yd = maxy;
  430.         **/
  431.         WaveX[xs] = xd;
  432.         WaveY[xs] = yd;
  433.  
  434.         xd = xdf1/scaled;
  435.         yd = ydf1/scaled;
  436.         /**
  437.         if(xd < minx) xd = minx;
  438.         if(xd > maxx) xd = maxx;
  439.         if(yd < miny) yd = miny;
  440.         if(yd > maxy) yd = maxy;
  441.         **/
  442.         WaveX[xs+Width] = xd;
  443.         WaveY[xs+Width] = yd;
  444.     }
  445. }
  446.